package com.example.springbootapi.service.impl;

import com.example.springbootapi.entity.OrderMain;
import com.example.springbootapi.dto.OrderMainDTO;
import com.example.springbootapi.vo.OrderMainVO;
import com.example.springbootapi.mapper.OrderMainMapper;
import com.example.springbootapi.service.OrderMainService;
import com.example.springbootapi.common.PageResult;
import com.example.springbootapi.common.BusinessException;
import com.example.springbootapi.common.ErrorCode;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 订单主表（存储订单整体信息，关联用户和地址） 服务实现类
 * 
 * @author 开发者
 * @version 1.0.0
 * @since 2025-10-03
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class OrderMainServiceImpl extends ServiceImpl<OrderMainMapper, OrderMain> implements OrderMainService {

    @Override
    public PageResult<OrderMainVO> page(Integer pageNum, Integer pageSize, OrderMainDTO queryDTO) {
        // 构建查询条件
        LambdaQueryWrapper<OrderMain> queryWrapper = new LambdaQueryWrapper<>();
        
        // 动态查询条件构建
        if (queryDTO != null) {
            // 订单编号（唯一，格式如&quot;20250520123456789012&quot;）查询条件
            if (StringUtils.hasText(queryDTO.getOrderNo())) {
                queryWrapper.like(OrderMain::getOrderNo, queryDTO.getOrderNo());
            }
            // 关联用户ID（外键：user.id）查询条件
            if (StringUtils.hasText(queryDTO.getUserId())) {
                queryWrapper.eq(OrderMain::getUserId, queryDTO.getUserId());
            }
            // 关联收货地址ID（外键：user_address.id）查询条件
            if (StringUtils.hasText(queryDTO.getAddressId())) {
                queryWrapper.eq(OrderMain::getAddressId, queryDTO.getAddressId());
            }
            // 订单总金额（所有商品金额之和，保留2位小数）查询条件
            if (queryDTO.getTotalAmount() != null) {
                queryWrapper.eq(OrderMain::getTotalAmount, queryDTO.getTotalAmount());
            }
            // 实际支付金额（总金额-优惠金额，保留2位小数）查询条件
            if (queryDTO.getPayAmount() != null) {
                queryWrapper.eq(OrderMain::getPayAmount, queryDTO.getPayAmount());
            }
            // 优惠金额（如优惠券、满减，保留2位小数）查询条件
            if (queryDTO.getDiscountAmount() != null) {
                queryWrapper.eq(OrderMain::getDiscountAmount, queryDTO.getDiscountAmount());
            }
            // 订单状态（1&#x3D;待支付，2&#x3D;已支付，3&#x3D;待发货，4&#x3D;已发货，5&#x3D;已完成，6&#x3D;已取消）查询条件
            if (queryDTO.getOrderStatus() != null) {
                queryWrapper.eq(OrderMain::getOrderStatus, queryDTO.getOrderStatus());
            }
            // 支付方式（0&#x3D;未支付，1&#x3D;微信支付，2&#x3D;支付宝，3&#x3D;银行卡）查询条件
            if (queryDTO.getPayType() != null) {
                queryWrapper.eq(OrderMain::getPayType, queryDTO.getPayType());
            }
            // 支付时间（未支付则为NULL）查询条件
            if (queryDTO.getPayTime() != null) {
                queryWrapper.eq(OrderMain::getPayTime, queryDTO.getPayTime());
            }
            // 订单备注（用户填写，如&quot;请尽快发货&quot;）查询条件
            if (StringUtils.hasText(queryDTO.getRemark())) {
                queryWrapper.like(OrderMain::getRemark, queryDTO.getRemark());
            }
            // 逻辑删除（0&#x3D;未删除，1&#x3D;已删除）查询条件
            if (StringUtils.hasText(queryDTO.getIsDeleted())) {
                queryWrapper.eq(OrderMain::getIsDeleted, queryDTO.getIsDeleted());
            }
            // 创建时间（下单时间）查询条件
            if (queryDTO.getCreateTime() != null) {
                queryWrapper.eq(OrderMain::getCreateTime, queryDTO.getCreateTime());
            }
            // 更新时间查询条件
            if (queryDTO.getUpdateTime() != null) {
                queryWrapper.eq(OrderMain::getUpdateTime, queryDTO.getUpdateTime());
            }
        }
        
        // 默认按创建时间倒序
        queryWrapper.orderByDesc(OrderMain::getCreateTime);
        
        // 分页查询
        IPage<OrderMain> page = new Page<>(pageNum, pageSize);
        IPage<OrderMain> result = this.page(page, queryWrapper);
        
        // 转换为VO
        List<OrderMainVO> voList = result.getRecords().stream()
                .map(this::convertToVO)
                .collect(Collectors.toList());
        
        return PageResult.<OrderMainVO>builder()
                .records(voList)
                .total(result.getTotal())
                .current(result.getCurrent())
                .size(result.getSize())
                .pages(result.getPages())
                .build();
    }

    @Override
    public OrderMainVO getById(Long id) {
        OrderMain entity = this.getById(id);
        if (entity == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "订单主表（存储订单整体信息，关联用户和地址）不存在");
        }
        return convertToVO(entity);
    }

    @Override
    public OrderMainVO create(OrderMainDTO DTO) {
        // 参数验证
        validateDTO(DTO);
        
        // 转换为实体
        OrderMain entity = convertToEntity(DTO);
        entity.setCreateTime(LocalDateTime.now());
        entity.setUpdateTime(LocalDateTime.now());
        
        // 保存
        boolean success = this.save(entity);
        if (!success) {
            throw new BusinessException(ErrorCode.OPERATION_FAILED, "创建订单主表（存储订单整体信息，关联用户和地址）失败");
        }
        
        return convertToVO(entity);
    }

    @Override
    public OrderMainVO update(Long id, OrderMainDTO DTO) {
        // 检查记录是否存在
        OrderMain existingEntity = this.getById(id);
        if (existingEntity == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "订单主表（存储订单整体信息，关联用户和地址）不存在");
        }
        
        // 参数验证
        validateDTO(DTO);
        
        // 更新实体
        OrderMain entity = convertToEntity(DTO);
        entity.setId(id);
        entity.setUpdateTime(LocalDateTime.now());
        
        // 保存
        boolean success = this.updateById(entity);
        if (!success) {
            throw new BusinessException(ErrorCode.OPERATION_FAILED, "更新订单主表（存储订单整体信息，关联用户和地址）失败");
        }
        
        return convertToVO(entity);
    }

    @Override
    public void delete(Long id) {
        // 检查记录是否存在
        OrderMain entity = this.getById(id);
        if (entity == null) {
            throw new BusinessException(ErrorCode.NOT_FOUND, "订单主表（存储订单整体信息，关联用户和地址）不存在");
        }
        
        // 删除
        boolean success = this.removeById(id);
        if (!success) {
            throw new BusinessException(ErrorCode.OPERATION_FAILED, "删除订单主表（存储订单整体信息，关联用户和地址）失败");
        }
    }

    @Override
    public void batchDelete(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "删除ID列表不能为空");
        }
        
        // 批量删除
        boolean success = this.removeByIds(ids);
        if (!success) {
            throw new BusinessException(ErrorCode.OPERATION_FAILED, "批量删除订单主表（存储订单整体信息，关联用户和地址）失败");
        }
    }

    // 关联关系查询方法将在后续版本中支持

    /**
     * 实体转VO
     */
    private OrderMainVO convertToVO(OrderMain entity) {
        if (entity == null) {
            return null;
        }
        
        OrderMainVO vo = new OrderMainVO();
        BeanUtils.copyProperties(entity, vo);
        return vo;
    }

    /**
     * DTO转实体
     */
    private OrderMain convertToEntity(OrderMainDTO dto) {
        if (dto == null) {
            return null;
        }
        
        OrderMain entity = new OrderMain;
        BeanUtils.copyProperties(dto, entity);
        return entity;
    }

    /**
     * 验证DTO参数
     */
    private void validateDTO(OrderMainDTO dto) {
        if (dto == null) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "订单主表（存储订单整体信息，关联用户和地址）信息不能为空");
        }
        
        // 必填字段验证
        if (!StringUtils.hasText(dto.getOrderNo())) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "订单编号（唯一，格式如&quot;20250520123456789012&quot;）不能为空");
        }
        if (!StringUtils.hasText(dto.getUserId())) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "关联用户ID（外键：user.id）不能为空");
        }
        if (!StringUtils.hasText(dto.getAddressId())) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "关联收货地址ID（外键：user_address.id）不能为空");
        }
        if (dto.getTotalAmount() == null) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "订单总金额（所有商品金额之和，保留2位小数）不能为空");
        }
        if (dto.getPayAmount() == null) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "实际支付金额（总金额-优惠金额，保留2位小数）不能为空");
        }
        if (dto.getOrderStatus() == null) {
            throw new BusinessException(ErrorCode.INVALID_PARAMS, "订单状态（1&#x3D;待支付，2&#x3D;已支付，3&#x3D;待发货，4&#x3D;已发货，5&#x3D;已完成，6&#x3D;已取消）不能为空");
        }
    }
}
